from flask import Flask, request, jsonify
from flask_cors import CORS
import os
import logging
import re
import traceback
from datetime import datetime, timedelta
from .db_helper import DBHelper
from .sms_service import SmsService
from .db_init import DatabaseInitializer
from dotenv import load_dotenv

# 配置日志rrrr
logging.basicConfig(
    level=logging.INFO, 
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()  # 确保日志输出到终端
    ]
)
logger = logging.getLogger(__name__)

# 加载环境变量
load_dotenv()

# 创建Flask应用实例
app = Flask(__name__)
app.logger.setLevel(logging.INFO)

# 加强CORS配置，确保跨域请求能够正常工作
# 使用更详细和严格的配置，明确指定所有必要的参数
CORS(app, 
     origins=["*"],  # 使用列表格式确保兼容性
     methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],  # 明确列出所有允许的HTTP方法
     allow_headers=["*"],  # 使用列表格式允许所有请求头
     expose_headers=["Content-Type", "Authorization"],  # 明确暴露的响应头
     max_age=86400,  # 预检请求结果缓存24小时
     send_wildcard=True,  # 当origin为*时发送通配符
     always_send=True,  # 始终发送CORS头，即使没有预检请求
     automatic_options=True  # 自动处理OPTIONS请求
)
logger.info("CORS配置已初始化，允许所有跨域请求")

# 确保Flask的werkzeug日志级别为INFO
logging.getLogger('werkzeug').setLevel(logging.INFO)

# 数据库配置（从环境变量读取，便于在不同环境中部署）
DB_CONFIG = {
    'host': os.getenv('DB_HOST', '47.104.247.126'),  # 修复中文句号为英文句号
    'port': int(os.getenv('DB_PORT', 3306)),
    'user': os.getenv('DB_USER', 'SMS'),
    'password': os.getenv('DB_PASSWORD', 'lp123456aA'),
    'database': os.getenv('DB_NAME', 'SMS')
}

# 短信服务配置
SMS_CONFIG = {
    'api_url': os.getenv('SMS_API_URL', 'https://apis.shlianlu.com/sms/inter/send'),
    'mch_id': os.getenv('SMS_MCH_ID', '1069842'),
    'app_id': os.getenv('SMS_APP_ID', '10031761267826805'),
    'template_id': os.getenv('SMS_TEMPLATE_ID', '39055'),
    'app_key': os.getenv('SMS_APP_KEY', '20bc7b2532ae4334966d524d076796c91')
}

# 应用配置
APP_CONFIG = {
    'valid_token': os.getenv('VALID_TOKEN', 'eyJhbGciOiJSUzI1NiIsImtpZCI6IjczQURFQjU'),
    'max_daily_sends': 5,     # 每日发送限制
    'min_send_interval': 60,  # 秒
    'code_expiration': 5      # 验证码有效期（分钟）
}

# 延迟初始化服务实例，避免在Gunicorn worker初始化时执行
db_helper = None
sms_service = None

def init_services():
    """
    初始化服务实例，在应用启动后调用
    """
    global db_helper, sms_service
    
    logger.info(f"[INIT] 开始初始化服务，数据库配置: host={DB_CONFIG['host']}, port={DB_CONFIG['port']}, user={DB_CONFIG['user']}, db={DB_CONFIG['database']}")
    
    # 测试环境变量加载
    logger.info(f"[INIT] 环境变量DB_HOST: {os.getenv('DB_HOST')}")
    logger.info(f"[INIT] 实际使用的数据库主机: {DB_CONFIG['host']}")
    
    # 初始化数据库表结构
    logger.info("[INIT] 正在初始化数据库...")
    try:
        init_success, init_message = DatabaseInitializer.init_database(
            DB_CONFIG['host'], 
            DB_CONFIG['port'], 
            DB_CONFIG['user'], 
            DB_CONFIG['password'], 
            DB_CONFIG['database']
        )
        logger.info(f"[INIT] 数据库初始化结果: {init_message}")
    except Exception as e:
        logger.error(f"[INIT] 数据库初始化失败: {str(e)}")
        import traceback
        logger.error(f"[INIT] 初始化错误堆栈: {traceback.format_exc()}")
    
    # 初始化服务实例
    try:
        logger.info("[INIT] 正在创建DBHelper实例...")
        db_helper = DBHelper(**DB_CONFIG)
        logger.info("[INIT] DBHelper实例创建成功")
        
        # 立即测试数据库连接
        logger.info("[INIT] 测试数据库连接和查询...")
        test_phone = "+18815376774"  # 测试手机号
        test_record = db_helper.get_latest_send_record_by_phone(test_phone)
        logger.info(f"[INIT] 测试查询结果: {test_record is not None}")
        
        sms_service = SmsService(**SMS_CONFIG)
        logger.info("[INIT] 服务实例初始化全部成功")
        return True
    except Exception as e:
        logger.error(f"[INIT] 服务实例初始化失败: {str(e)}")
        import traceback
        logger.error(f"[INIT] 初始化错误堆栈: {traceback.format_exc()}")
        return False

# 全局标志变量，用于确保初始化只运行一次
_services_initialized = False

# 使用before_request并结合标志变量来实现类似before_first_request的功能
@app.before_request
def before_request():
    """
    在处理请求前检查并初始化服务
    """
    global _services_initialized
    if not _services_initialized:
        # 只有在初始化成功后才设置标志为True
        success = init_services()
        if success:
            _services_initialized = True
        else:
            logger.warning("服务初始化失败，将在下次请求时重新尝试")

def validate_token(request):
    """
    验证请求头中的Bearer Token是否有效
    
    Args:
        request: Flask请求对象
        
    Returns:
        tuple: (是否有效, 错误信息)
    """
    auth_header = request.headers.get('Authorization')
    if not auth_header:
        return False, "缺少Authorization请求头"
    
    if not auth_header.startswith('Bearer '):
        return False, "Authorization格式错误，应为Bearer token格式"
    
    bearer_token = auth_header[7:].strip()
    if bearer_token != APP_CONFIG['valid_token']:
        return False, "Token值错误"
    
    return True, ""

def validate_phone_number(phone):
    """
    验证手机号格式
    
    Args:
        phone: 手机号
        
    Returns:
        tuple: (是否有效, 错误信息)
    """
    if not phone:
        return False, "手机号不能为空"
    
    
    return True, ""

def validate_ip(ip):
    """
    验证IP地址格式
    
    Args:
        ip: IP地址
        
    Returns:
        tuple: (是否有效, 错误信息)
    """
    if not ip:
        return False, "IP地址不能为空"
    
    # 简单的IP格式验证
    pattern = r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'
    if not re.match(pattern, ip):
        return False, "IP地址格式错误"
    
    return True, ""

def create_response(code, msg, data=None, count=0):
    """
    创建统一格式的响应对象
    
    Args:
        code: 响应状态码
        msg: 响应消息
        data: 响应数据，默认为空对象
        count: 计数，默认为0
        
    Returns:
        JSON响应对象
    """
    if data is None:
        data = {}
    
    response_data = {
        'code': code,
        'msg': msg,
        'data': data,
        'count': count,
        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    }
    logger.info(f"准备响应 - 状态码: {code}, 消息: {msg}")
    return jsonify(response_data)


@app.route('/api/sms', methods=['POST', 'OPTIONS'])
def sms_handler():
    logger.info(f"[SMS_HANDLER] 收到API调用请求: {request.method} {request.path}")
    logger.info(f"[SMS_HANDLER] 请求头: {dict(request.headers)}")
    """
    短信处理接口，支持发送短信和验证短信
    
    POST /api/sms: 处理短信发送或验证码验证请求
    OPTIONS /api/sms: 处理跨域预检请求
    """
    
    global db_helper, sms_service
    
    # 初始化服务
    if not _services_initialized:
        logger.info("[SMS_HANDLER] 服务尚未初始化，开始初始化...")
        if not init_services():
            logger.error("[SMS_HANDLER] 服务初始化失败")
            return create_response(500, '服务初始化失败', {})
        logger.info("[SMS_HANDLER] 服务初始化完成")
    
    # 验证服务实例存在
    if db_helper is None:
        logger.error("[SMS_HANDLER] 错误: db_helper实例不存在")
        return create_response(500, '数据库服务未初始化', {})
    
    # 获取客户端IP
    client_ip = request.remote_addr or '127.0.0.1'
    logger.info(f"[SMS_HANDLER] 客户端实际IP: {client_ip}")

    # 对于OPTIONS请求，调用全局handle_options函数处理，确保正确设置CORS头
    if request.method == 'OPTIONS':
        logger.info("[SMS_HANDLER] 处理OPTIONS预检请求，调用全局handle_options函数")
        return handle_options('')
    
    # 验证Token
    is_valid, token_error = validate_token(request)
    if not is_valid:
        logger.warning(f"[SMS_HANDLER] Token验证失败: {token_error}")
        # 返回正确的HTTP状态码401
        return create_response(401, f'密钥不合法或者已经过期: {token_error}', {}), 401
    
    try:
        # 获取和验证请求数据
        try:
            data = request.get_json()
            logger.info(f"[SMS_HANDLER] 请求体: {data}")
        except Exception as e:
            logger.error(f"[SMS_HANDLER] 请求解析失败: {str(e)}")
            return create_response(400, '请求数据格式错误，请使用JSON格式', {})
            
        if not data:
            logger.warning("[SMS_HANDLER] 请求数据为空")
            return create_response(400, '请求数据不能为空', {})
        
        # 日志记录请求参数
        request_ip = data.get('ip', 'N/A')
        logger.info(f"[SMS_HANDLER] 处理请求: {data.get('tableView')} - 请求IP: {request_ip} - 客户端IP: {client_ip} - Phone: {data.get('phone')}")
        
        table_view = data.get('tableView')
        ip = data.get('ip')
        phone = data.get('phone')
        
        # 验证必要参数
        if not table_view:
            logger.warning("[SMS_HANDLER] 缺少必要参数: tableView")
            return create_response(400, '缺少必要参数: tableView', {})
        
        if not phone:
            logger.warning("[SMS_HANDLER] 缺少必要参数: phone")
            return create_response(400, '缺少必要参数: phone', {})
        
        # 只有发送短信请求需要验证IP
        if table_view == 'send':
            if not ip:
                logger.warning("[SMS_HANDLER] send模式缺少必要参数: ip")
                return create_response(400, '缺少必要参数: ip', {})
            
            # 验证IP格式1
            is_valid_ip, ip_error = validate_ip(ip)
            if not is_valid_ip:
                logger.warning(f"[SMS_HANDLER] IP格式验证失败: {ip_error}")
                return create_response(400, ip_error, {})
        elif table_view == 'sendok':
            # 对于sendok模式，记录客户端IP和请求中提供的IP（如果有）
            logger.info(f"[SMS_HANDLER] sendok模式 - 客户端实际IP: {client_ip}, 请求中提供的IP: {ip or '未提供'}")
        else:
            logger.warning(f"[SMS_HANDLER] 无效的tableView值: {table_view}")
        
        # 验证手机号格式
        is_valid_phone, phone_error = validate_phone_number(phone)
        if not is_valid_phone:
            logger.warning(f"[SMS_HANDLER] 手机号格式验证失败: {phone_error}")
            return create_response(400, phone_error, {})
        
        # 获取最新发送记录
        latest_record = None
        try:
            # 对于验证请求，只需要通过手机号查询最新记录
            if table_view == 'sendok':
                logger.info(f"[SMS_HANDLER] sendok模式 - 开始查询手机号 {phone} 的最新验证码记录")
                logger.info(f"[SMS_HANDLER] 调用db_helper.get_latest_send_record_by_phone({phone})")
                latest_record = db_helper.get_latest_send_record_by_phone(phone)
                logger.info(f"[SMS_HANDLER] 查询结果: {latest_record}")
                if latest_record:
                    logger.info(f"[SMS_HANDLER] 找到记录 - ID: {latest_record.get('ID')}, 验证码: {latest_record.get('ccode')}, 时间: {latest_record.get('DDATE')}")
                else:
                    logger.warning(f"[SMS_HANDLER] 未找到手机号 {phone} 的发送记录")
            else:
                logger.info(f"[SMS_HANDLER] 使用IP和Phone查询记录 - IP: {ip}, Phone: {phone}")
                latest_record = db_helper.get_latest_send_record(ip, phone)
        except Exception as e:
            import traceback
            logger.error(f"[SMS_HANDLER] 获取发送记录失败: {str(e)}")
            logger.error(f"[SMS_HANDLER] 详细错误堆栈: {traceback.format_exc()}")
            return create_response(500, f'数据库查询失败: {str(e)}', {})
        
        # 处理发送短信请求
        if table_view == 'send':
            return handle_sms_send(ip, phone, latest_record)
        
        # 处理验证码验证请求
        elif table_view == 'sendok':
            return handle_sms_verify(data, latest_record)
        
        # 处理验证码验证并返回经销商信息
        elif table_view == 'sendres':
            # 首先验证验证码
            input_code = data.get('ccode')
            nation = data.get('nation')
            distributor_id = data.get('id')
            
            # 验证必要参数
            if not input_code:
                logger.warning("[SMS_RES] 缺少验证码参数ccode")
                return create_response(400, '缺少必要参数: ccode', {})
            
            # nation和id必须至少有一个
            if not nation and not distributor_id:
                logger.warning("[SMS_RES] 缺少必要参数: nation或id至少需要提供一个")
                return create_response(400, '缺少必要参数: nation或id至少需要提供一个', {})
            
            # 验证验证码（复用handle_sms_verify的逻辑）
            verify_result = handle_sms_verify(data, latest_record)
            verify_data = verify_result.json
            
            # 检查验证码是否验证成功
            if verify_data.get('code') != 200:
                logger.warning("[SMS_RES] 验证码验证失败")
                return verify_result
            
            # 验证码验证成功，查询经销商信息
            logger.info(f"[SMS_RES] 验证码验证成功，开始查询经销商信息 - nation: {nation}, id: {distributor_id}")
            
            try:
                if distributor_id:
                    # 根据ID查询经销商
                    distributor = db_helper.get_distributor_by_id(distributor_id)
                    
                    # 如果同时提供了nation，验证国家是否匹配
                    if distributor and (not nation or distributor.get('nation') == nation):
                        logger.info(f"[SMS_RES] 成功查询到经销商: {distributor.get('distributorName')}")
                        # 将nation字段提升到顶层并添加list结构，保持与经销商查询相同格式
                        result = {
                            'list': {distributor.get('nation'): [distributor]},
                            'total': 1,
                            'page': 1,
                            'page_size': 1
                        }
                        logger.info(f"[SMS_RES] 成功查询到经销商: {distributor.get('distributorName')}")
                        return create_response(200, '查询成功', result)
                    else:
                        logger.warning(f"[SMS_RES] 未找到匹配的经销商 - nation: {nation}, id: {distributor_id}")
                        return create_response(404, '经销商不存在', {})
                elif nation:
                    # 根据国家查询经销商列表
                    distributors = db_helper.get_distributors_by_nation(nation)
                    
                    if distributors:
                        logger.info(f"[SMS_RES] 成功查询到{len(distributors)}个经销商")
                        # 返回与经销商按国家查询相同格式的响应
                        return create_response(200, '查询成功', {
                            'list': {nation: distributors},
                            'total': len(distributors),
                            'page': 1,
                            'page_size': len(distributors)
                        })
                    else:
                        logger.warning(f"[SMS_RES] 未找到该国家的经销商 - nation: {nation}")
                        return create_response(404, '经销商不存在', {})
            except Exception as e:
                logger.error(f"[SMS_RES] 查询经销商信息失败: {str(e)}")
                return create_response(500, '数据库查询失败', {})
        
        # 非法的请求类型
        else:
            logger.warning(f"无效的tableView值: {table_view}")
            return create_response(400, f'无效的请求类型: {table_view}', {})
    
    except json.JSONDecodeError:
        logger.error("请求数据不是有效的JSON格式")
        return create_response(400, '请求数据格式错误，请使用JSON格式', {})
    except Exception as e:
        logger.error(f"处理短信请求时发生错误: {str(e)}", exc_info=True)
        return create_response(500, '服务器内部错误', {})


def handle_sms_send(ip, phone, latest_record):
    """
    处理短信发送逻辑
    
    Args:
        ip: 请求IP地址
        phone: 手机号码
        latest_record: 最新发送记录
        
    Returns:
        JSON响应对象
    """
    try:
        # 检查服务初始化状态
        if db_helper is None or sms_service is None:
            logger.error("服务未初始化: db_helper或sms_service为None")
            return create_response(500, '服务初始化失败，请稍后重试', {})
            
        # 检查每日发送次数限制
        daily_count = db_helper.get_daily_count(ip, phone)
        if daily_count >= APP_CONFIG['max_daily_sends']:
            logger.warning(f"每日发送次数超限: {phone} - {ip}")
            return create_response(429, f'该电话号码或者IP今日已发送{daily_count}条短信，超过限制', {})
        
        # 检查发送时间间隔限制
        if latest_record:
            last_send_time = latest_record['DDATE']
            time_diff = (datetime.now() - last_send_time).total_seconds()
            
            if time_diff <= APP_CONFIG['min_send_interval']:
                remaining_time = int(APP_CONFIG['min_send_interval'] - time_diff)
                logger.warning(f"发送频率超限: {phone} - 剩余{remaining_time}秒")
                return create_response(429, f'发送时间间隔不足，请{remaining_time}秒后再试', {})
        
        # 生成并发送验证码
        verification_code = sms_service.generate_verification_code()
        logger.info(f"生成验证码: {verification_code} 用于 {phone}")
        
        response = sms_service.send_sms(phone, verification_code)
        logger.info(f"短信服务响应: {response}")
        
        # 处理发送结果
        if response.get('status') == '00':
            # 保存发送记录
            task_id = response.get('taskId', '')
            try:
                db_helper.insert_send_record(ip, phone, verification_code, task_id)
                logger.info(f"短信发送成功: {phone} - TaskID: {task_id}")
                
                # 返回成功响应，不包含验证码
                return create_response(200, '验证码发送成功', {
                    'taskId': task_id,
                    'expireTime': (datetime.now() + timedelta(minutes=APP_CONFIG['code_expiration'])).strftime('%Y-%m-%d %H:%M:%S')
                })
            except Exception as e:
                logger.error(f"保存发送记录失败: {str(e)}")
                return create_response(500, '短信发送成功但记录保存失败', {})
        else:
            # 获取详细的错误信息
            error_msg = response.get('message', f'发送失败，错误码: {response.get("status", "未知")}')
            logger.error(f"短信发送失败111: {phone} - {error_msg}")
            return create_response(400, error_msg, {})
            
    except Exception as e:
        logger.error(f"处理短信发送时发生错误: {str(e)}", exc_info=True)
        return create_response(500, '服务器内部错误', {})


def handle_sms_verify(data, latest_record):
    """
    处理验证码验证逻辑
    
    Args:
        data: 请求数据
        latest_record: 最新发送记录
        
    Returns:
        JSON响应对象
    """
    logger.info("[SMS_VERIFY] 开始处理验证码验证")
    
    try:
        # 检查服务初始化状态
        if db_helper is None:
            logger.error("[SMS_VERIFY] 服务未初始化: db_helper为None")
            return create_response(500, '服务初始化失败，请稍后重试', {})
            
        # 验证ccode参数
        input_code = data.get('ccode')
        logger.info(f"[SMS_VERIFY] 输入的验证码: {input_code}")
        
        if not input_code:
            logger.warning("[SMS_VERIFY] 缺少验证码参数ccode")
            return create_response(400, '缺少必要参数: ccode', {})
        
        # 检查是否有发送记录
        if not latest_record:
            logger.warning("[SMS_VERIFY] 验证失败: 未找到该手机号的发送记录")
            return create_response(404, '未找到验证码发送记录，请先获取验证码', {})
        
        logger.info(f"[SMS_VERIFY] 找到记录 - ID: {latest_record.get('ID')}, 手机号: {latest_record.get('PHONE')}, 存储的验证码: {latest_record.get('ccode')}")
        
        # 检查验证码是否过期
        send_time = latest_record['DDATE']
        expire_time = send_time + timedelta(minutes=APP_CONFIG['code_expiration'])
        now = datetime.now()
        is_expired = now > expire_time
        
        logger.info(f"[SMS_VERIFY] 发送时间: {send_time}, 过期时间: {expire_time}, 当前时间: {now}, 状态: {'已过期' if is_expired else '有效'}")
        
        if is_expired:
            logger.warning(f"[SMS_VERIFY] 验证码已过期: {latest_record['ccode']}")
            return create_response(400, '验证码已过期，请重新获取', {})
        
        # 检查验证码是否匹配
        stored_code = latest_record['ccode']
        if input_code == stored_code:
            logger.info(f"[SMS_VERIFY] 验证码验证成功: {latest_record['PHONE']}")
            # 返回清晰的成功信息和详细数据
            return create_response(200, '验证码验证成功', {
                'verified': True,
                'phone': latest_record['PHONE'],
                'sendTime': send_time.strftime('%Y-%m-%d %H:%M:%S'),
                'remainingTime': int((expire_time - now).total_seconds())  # 剩余有效时间（秒）
            })
        else:
            logger.warning(f"[SMS_VERIFY] 验证码验证失败: 输入的验证码 {input_code} 与存储的验证码 {stored_code} 不匹配")
            return create_response(400, '验证码错误，请重新输入', {})
            
    except Exception as e:
        logger.error(f"[SMS_VERIFY] 处理验证码验证时发生错误: {str(e)}")
        logger.error(f"[SMS_VERIFY] 详细错误堆栈: {traceback.format_exc()}")
        return create_response(500, '服务器内部错误，请联系管理员', {})

@app.after_request
def after_request(response):
    """
    处理所有响应后的钩子，记录日志
    不再手动添加CORS头，避免与Flask-CORS产生冲突
    """
    # 只记录日志，不添加CORS头
    logger.info(f"响应返回 - 状态码: {response.status_code}")
    
    return response

# 全局处理OPTIONS请求 - 保留此路由以确保兼容性
# Flask-CORS会自动处理OPTIONS请求，但我们保留此路由以确保完全兼容
@app.route('/', defaults={'path': ''}, methods=['OPTIONS'])
@app.route('/<path:path>', methods=['OPTIONS'])
def handle_options(path):
    """全局处理OPTIONS请求，确保跨域预检请求能够正确响应
    不再手动添加CORS头，由Flask-CORS统一处理
    """
    logger.info(f"[OPTIONS_HANDLER] 处理路径 {path} 的OPTIONS请求")
    # 创建响应对象
    response = jsonify({})
    response.status_code = 204
    
    # 不再手动添加CORS头，避免与Flask-CORS产生冲突
    # 让Flask-CORS库来统一处理所有CORS相关的头信息
    
    return response

# 地区管理相关API - 按照用户要求修改
@app.route('/api/region', methods=['GET', 'POST', 'OPTIONS'])
def region_handler():
    """
    地区管理接口
    POST: 支持新增、修改和查询地区信息
    - 查询操作: {"operation_type": "query", "id": 地区ID} 或 {"operation_type": "query", "nation": "国家名称"} 或 {"operation_type": "query"}
    - 新增操作: {"operation_type": "add", "nation": "国家", "number": "10", "sort": 0}
    - 修改操作: {"operation_type": "update", "id": 地区ID, "nation": "国家", "number": "10", "sort": 0}
    """
    
    # 对于OPTIONS请求，调用全局handle_options函数处理，确保正确设置CORS头
    if request.method == 'OPTIONS':
        logger.info("[REGION_HANDLER] 处理OPTIONS预检请求，调用全局handle_options函数")
        return handle_options('')
    
    # 验证Token
    is_valid, token_error = validate_token(request)
    if not is_valid:
        logger.warning(f"Token验证失败: {token_error}")
        return create_response(401, f'密钥不合法或者已经过期: {token_error}', {}), 401
    
    try:
        # 根据请求方法获取数据
        if request.method == 'GET':
            # 从查询参数获取数据
            data = request.args.to_dict()
            # 转换数字类型参数
            if 'page' in data:
                data['page'] = int(data['page'])
            if 'page_size' in data:
                data['page_size'] = int(data['page_size'])
            if 'id' in data:
                data['id'] = int(data['id'])
            # 如果没有指定操作类型，默认为查询
            if 'operation_type' not in data:
                data['operation_type'] = 'query'
        else:
            # 从请求体获取数据
            data = request.get_json()
            if not data:
                return create_response(400, '请求数据不能为空', {})
        
        # 获取操作类型，默认为查询
        operation_type = data.get('operation_type', 'query')
        
        if operation_type == 'query':
            # 查询操作
            region_id = data.get('id')
            nation = data.get('nation')
            page = data.get('page', 1)
            page_size = data.get('page_size', 10)
            
            # 参数验证
            if page < 1:
                page = 1
            if page_size < 1 or page_size > 100:
                page_size = 10
            
            # 根据参数决定查询方式
            if region_id:
                # 根据ID查询（单个查询不分页）
                region = db_helper.get_region_by_id(region_id)
                if region:
                    return create_response(200, '查询成功', region)
                else:
                    return create_response(404, '地区不存在', {})
            elif nation:
                # 根据国家名称查询（单个查询不分页）
                region = db_helper.get_region_by_nation(nation)
                if region:
                    return create_response(200, '查询成功', region)
                else:
                    return create_response(404, '地区不存在', {})
            else:
                # 查询所有地区（支持分页和排序）
                sort_field = data.get('sort_field')
                sort_order = data.get('sort_order', 'asc')
                
                regions = db_helper.get_all_regions(page, page_size, sort_field, sort_order)
                
                # 获取总数（用于分页）
                total_count = len(db_helper.get_all_regions(1, 10000))  # 临时获取总数
                
                return create_response(200, '查询成功', {
                    'list': regions,
                    'total': total_count,
                    'page': page,
                    'page_size': page_size,
                    'sort_field': sort_field,
                    'sort_order': sort_order
                }, total_count)
                
        elif operation_type == 'add':
            # 新增操作
            # 验证必要参数
            if 'nation' not in data:
                return create_response(400, '缺少必要参数: nation', {})
            if 'number' not in data:
                return create_response(400, '缺少必要参数: number', {})
            
            nation = data.get('nation')
            
            # 检查名称是否已存在
            existing_region = db_helper.get_region_by_nation(nation)
            if existing_region:
                return create_response(400, '国家名称已存在', {})
            
            # 设置默认值
            data['id'] = 0  # 确保是新增操作
            data['sort'] = data.get('sort', 0)
            
            # 插入地区
            result = db_helper.insert_or_update_region(data)
            return create_response(200, '新增成功', result)
            
        elif operation_type == 'update':
            # 修改操作
            # 验证必要参数
            if 'id' not in data or not data['id'] or data['id'] <= 0:
                return create_response(400, '缺少必要参数: id 或 id无效', {})
            if 'nation' not in data:
                return create_response(400, '缺少必要参数: nation', {})
            if 'number' not in data:
                return create_response(400, '缺少必要参数: number', {})
            
            region_id = data['id']
            nation = data.get('nation')
            
            # 检查名称是否已存在（修改时排除自身）
            existing_region = db_helper.get_region_by_nation(nation)
            if existing_region and existing_region['id'] != region_id:
                return create_response(400, '国家名称已存在', {})
            
            # 确保sort字段存在
            data['sort'] = data.get('sort', 0)
            
            # 更新地区
            result = db_helper.insert_or_update_region(data)
            if 'error' in result:
                return create_response(404, result['error'], {})
            return create_response(200, '更新成功', result)
            
        else:
            return create_response(400, f'不支持的操作类型: {operation_type}', {})
    
    except Exception as e:
        logger.error(f"处理地区请求时发生错误: {str(e)}", exc_info=True)
        # 返回真实的错误信息给前端，便于调试
        return create_response(500, f'服务器内部错误: {str(e)}', {})

# 经销商管理相关API
@app.route('/api/distributor/simple', methods=['POST', 'OPTIONS'])
def distributor_simple_handler():
    """
    简化版经销商查询接口
    返回字段：distributorName、lat、lng、id、ico、nation、distance
    支持分页查询、可选排序，以及按经销商名称进行模糊查询
    
    Args:
        page: 页码，默认1
        page_size: 每页数量，默认10，最大1000
        sort_field: 排序字段
        sort_order: 排序方向，asc（升序）或desc（降序），默认asc
        distributorName: 经销商名称，用于模糊查询筛选
    
    Returns:
        JSON响应，包含经销商列表（按国家分组）和分页信息
    """
    # 对于OPTIONS请求，调用全局handle_options函数处理，确保正确设置CORS头
    if request.method == 'OPTIONS':
        logger.info("[DISTRIBUTOR_SIMPLE_HANDLER] 处理OPTIONS预检请求，调用全局handle_options函数")
        return handle_options('')
    
    # 验证Token
    is_valid, token_error = validate_token(request)
    if not is_valid:
        return create_response(401, f'密钥不合法或者已经过期: {token_error}', {}), 401
        
    try:
        # 从请求体获取数据
        data = request.get_json() or {}
        
        # 处理可能存在的operation_type参数，兼容其他接口的调用方式
        operation_type = data.get('operation_type', 'query')
        if operation_type != 'query':
            return create_response(400, '简化版经销商接口只支持查询操作', {})
        
        # 获取分页参数
        page = data.get('page', 1)
        page_size = data.get('page_size', 10)
        distributor_name = data.get('distributorName')
        nation = data.get('nation')  # 添加缺失的nation变量定义
        
        # 参数验证
        if page < 1:
            page = 1
        if page_size < 1 or page_size > 1000:
            page_size = 10
        # 不再验证和使用排序参数，使用默认排序模式（完全按照distributor表的sort字段）
          
        # 查询简化版经销商信息，支持按国家和名称筛选
        distributors = db_helper.search_distributors_simple(nation, distributor_name, page, page_size)
          
        # 获取总数，支持按国家和名称筛选
        total_count = db_helper.get_distributors_simple_total_count(nation, distributor_name)
        
        # 格式转换：将经销商按国家分组
        formatted_result = {}
        for distributor in distributors:
            distributor_nation = distributor['nation']
            if distributor_nation not in formatted_result:
                formatted_result[distributor_nation] = []
            formatted_result[distributor_nation].append(distributor)
        
        # 确保每个国家下的经销商按sort字段排序
        for nation_name in formatted_result:
            formatted_result[nation_name] = sorted(formatted_result[nation_name], key=lambda d: d.get('sort', 0))
        
        # 确保第一层（nation）按region表的SORT字段排序
        # 获取所有国家及其对应的排序值
        with db_helper.get_connection() as conn:
            with conn.cursor() as cursor:
                cursor.execute("SELECT nation, sort FROM region WHERE nation IN %s", (tuple(formatted_result.keys()),))
                region_sorts = {row['nation']: row['sort'] for row in cursor.fetchall()}
        
        # 按region的sort值对国家进行排序
        sorted_nations = sorted(formatted_result.keys(), key=lambda n: region_sorts.get(n, 9999))
        
        # 创建排序后的结果字典
        sorted_result = {}
        for nation_name in sorted_nations:
            sorted_result[nation_name] = formatted_result[nation_name]
        formatted_result = sorted_result
        
        # 构建统一格式的响应数据
        response_data = {
            'list': formatted_result,  # 始终返回按国家分组的字典结构
            'total': total_count,
            'page': page,
            'page_size': page_size
        }
        
        # 使用统一的响应格式返回结果
        return create_response(200, '查询成功', response_data, total_count), 200
        
    except Exception as e:
        error_msg = f"数据库错误: {str(e)}"
        logger.error(f"处理简化版经销商查询请求时发生错误: {error_msg}", exc_info=True)
        return create_response(500, error_msg, {})

@app.route('/api/distributor', methods=['POST', 'OPTIONS'])
def distributor_handler():
    """
    经销商管理接口
    POST: 支持查询、新增和修改经销商信息
    - 查询操作: {"operation_type": "query", "id": 经销商ID} 或 {"operation_type": "query", "nation": "国家名称"} 或 {"operation_type": "query"}
    - 新增操作: {"operation_type": "add", "nation": "国家", "distributorName": "经销商名称", ...}
    - 修改操作: {"operation_type": "update", "id": 经销商ID, "nation": "国家", "distributorName": "经销商名称", ...}
    """
    
    # 对于OPTIONS请求，调用全局handle_options函数处理，确保正确设置CORS头
    if request.method == 'OPTIONS':
        logger.info("[DISTRIBUTOR_HANDLER] 处理OPTIONS预检请求，调用全局handle_options函数")
        return handle_options('')
    
    # 验证Token
    is_valid, token_error = validate_token(request)
    if not is_valid:
        logger.warning(f"Token验证失败: {token_error}")
        return create_response(401, f'密钥不合法或者已经过期: {token_error}', {}), 401
    
    try:
        # 从请求体获取数据
        data = request.get_json() or {}
        
        # 获取操作类型，默认为查询
        operation_type = data.get('operation_type', 'query')
        
        if operation_type == 'query':
            # 查询操作
            distributor_id = data.get('id')
            nation = data.get('nation')
            distributor_name = data.get('distributorName')
            address = data.get('address')
            page = data.get('page', 1)
            page_size = data.get('page_size', 10)
            
            # 参数验证
            if page < 1:
                page = 1
            if page_size < 1 or page_size > 100:
                page_size = 10
            # 不再验证和使用排序参数，使用默认排序模式
            
            if distributor_id:
                # 根据ID查询（单个查询不分页）
                distributor = db_helper.get_distributor_by_id(distributor_id)
                if distributor:
                    return create_response(200, '查询成功', distributor)
                else:
                    return create_response(404, '经销商不存在', {})
            elif nation or distributor_name or address:
                # 搜索经销商（支持分页和排序）
                distributors = db_helper.search_distributors(nation, distributor_name, address, page, page_size)
                
                # 获取总数（用于分页），不使用分页参数
                total_count = len(db_helper.search_distributors(nation, distributor_name, address, 1, 10000))
                
                # 格式转换：如果只按国家查询，返回 {"国家名称": [经销商列表]} 格式
                if nation and not distributor_name and not address:
                    # 确保经销商按sort字段排序
                    sorted_distributors = sorted(distributors, key=lambda d: d.get('sort', 0))
                    # 按国家分组的格式
                    formatted_result = {
                        'list': {nation: sorted_distributors},
                        'total': total_count,
                        'page': page,
                        'page_size': page_size
                    }
                    return create_response(200, '查询成功', formatted_result, total_count)
                else:
                    # 无论使用什么查询条件，都将结果按国家分组
                    formatted_result = {}
                    for distributor in distributors:
                        distributor_nation = distributor.get('nation', 'Unknown')
                        if distributor_nation not in formatted_result:
                            formatted_result[distributor_nation] = []
                        formatted_result[distributor_nation].append(distributor)
                    
                    # 确保每个国家下的经销商按sort字段排序
                    for nation_name in formatted_result:
                        formatted_result[nation_name] = sorted(formatted_result[nation_name], key=lambda d: d.get('sort', 0))
                    
                    # 确保第一层（nation）按region表的SORT字段排序
                    # 获取所有国家及其对应的排序值
                    with db_helper.get_connection() as conn:
                        with conn.cursor() as cursor:
                            cursor.execute("SELECT nation, sort FROM region WHERE nation IN %s", (tuple(formatted_result.keys()),))
                            region_sorts = {row['nation']: row['sort'] for row in cursor.fetchall()}
                    
                    # 按region的sort值对国家进行排序
                    sorted_nations = sorted(formatted_result.keys(), key=lambda n: region_sorts.get(n, 9999))
                    
                    # 创建排序后的结果字典
                    sorted_result = {}
                    for nation_name in sorted_nations:
                        sorted_result[nation_name] = formatted_result[nation_name]
                    formatted_result = sorted_result
                    
                    return create_response(200, '查询成功', {
                        'list': formatted_result,  # 返回按国家分组的结构，确保nation在上一级
                        'total': total_count,
                        'page': page,
                        'page_size': page_size
                    }, total_count)
            else:
                # 获取所有经销商（支持分页和排序）
                distributors = db_helper.search_distributors(page=page, page_size=page_size)
                
                # 获取总数
                total_count = len(db_helper.search_distributors(page=1, page_size=10000))
                
                # 格式转换：将当前页经销商按国家分组
                formatted_result = {}
                for distributor in distributors:
                    distributor_nation = distributor.get('nation', 'Unknown')
                    if distributor_nation not in formatted_result:
                        formatted_result[distributor_nation] = []
                    formatted_result[distributor_nation].append(distributor)
                
                # 确保每个国家下的经销商按sort字段排序
                for nation_name in formatted_result:
                    formatted_result[nation_name] = sorted(formatted_result[nation_name], key=lambda d: d.get('sort', 0))
                
                # 确保第一层（nation）按region表的SORT字段排序
                # 获取所有国家及其对应的排序值
                with db_helper.get_connection() as conn:
                    with conn.cursor() as cursor:
                        cursor.execute("SELECT nation, sort FROM region WHERE nation IN %s", (tuple(formatted_result.keys()),))
                        region_sorts = {row['nation']: row['sort'] for row in cursor.fetchall()}
                
                # 按region的sort值对国家进行排序
                sorted_nations = sorted(formatted_result.keys(), key=lambda n: region_sorts.get(n, 9999))
                
                # 创建排序后的结果字典
                sorted_result = {}
                for nation_name in sorted_nations:
                    sorted_result[nation_name] = formatted_result[nation_name]
                formatted_result = sorted_result
                
                return create_response(200, '查询成功', {
                    'list': formatted_result,
                    'total': total_count,
                    'page': page,
                    'page_size': page_size
                }, total_count)
                
        elif operation_type == 'add':
            # 新增操作
            # 验证必要参数
            if 'nation' not in data or 'distributorName' not in data:
                return create_response(400, '缺少必要参数: nation 或 distributorName', {})
            
            # 检查名称是否已存在
            distributors = db_helper.search_distributors(
                nation=data['nation'], 
                distributor_name=data['distributorName']
            )
            if distributors:
                return create_response(400, '该国家下的经销商名称已存在', {})
            
            # 设置默认值
            data['id'] = 0  # 确保是新增操作
            # 为sort字段设置默认值（如果未提供）
            if 'sort' not in data:
                data['sort'] = 0
            
            # 插入经销商
            result = db_helper.insert_or_update_distributor(data)
            return create_response(200, '新增成功', result)
            
        elif operation_type == 'update':
            # 修改操作
            # 验证必要参数
            if 'id' not in data or not data['id'] or data['id'] <= 0:
                return create_response(400, '缺少必要参数: id 或 id无效', {})
            if 'nation' not in data or 'distributorName' not in data:
                return create_response(400, '缺少必要参数: nation 或 distributorName', {})
            
            distributor_id = data['id']
            # 为sort字段设置默认值（如果未提供）
            if 'sort' not in data:
                data['sort'] = 0
            
            # 检查名称是否已存在（更新时排除自身）
            distributors = db_helper.search_distributors(
                nation=data['nation'], 
                distributor_name=data['distributorName']
            )
            if distributors and distributors[0]['id'] != distributor_id:
                return create_response(400, '该国家下的经销商名称已存在', {})
            
            # 更新经销商
            result = db_helper.insert_or_update_distributor(data)
            if not result:
                return create_response(404, '经销商不存在', {})
            return create_response(200, '更新成功', result)
            
        elif operation_type == 'delete':
            # 删除操作
            distributor_id = data.get('id')
            if not distributor_id or distributor_id <= 0:
                return create_response(400, '缺少必要参数: id 或 id无效', {})
            
            success = db_helper.delete_distributor(distributor_id)
            if success:
                return create_response(200, '删除成功', {})
            else:
                return create_response(404, '经销商不存在', {})
            
        else:
            return create_response(400, f'不支持的操作类型: {operation_type}', {})
    
    except Exception as e:
        error_msg = f"数据库错误: {str(e)}"
        logger.error(f"处理经销商请求时发生错误: {error_msg}", exc_info=True)
        return create_response(500, error_msg, {})

if __name__ == '__main__':
    # 在开发环境中启动应用
    # 生产环境应使用Gunicorn或其他WSGI服务器
    app.run(host='0.0.0.0', port=8091, debug=True)